குறிப்பு எண்ணும் நெறிமுறைகள்: சுழற்சி குப்பை சேகரிப்பை செயல்படுத்துதல்

குறிப்பு எண்ணுதல் (Reference counting) என்பது ஒரு நினைவக மேலாண்மை நுட்பமாகும், இதில் நினைவகத்தில் உள்ள ஒவ்வொரு பொருளுக்கும் (object) அதைச் சுட்டிக்காட்டும் குறிப்புகளின் (references) எண்ணிக்கை பராமரிக்கப்படுகிறது. ஒரு பொருளின் குறிப்பு எண்ணிக்கை பூஜ்ஜியமாகக் குறையும்போது, வேறு எந்தப் பொருளும் அதைக் குறிப்பிடவில்லை என்று அர்த்தம், மேலும் அந்தப் பொருளைப் பாதுகாப்பாக நீக்க முடியும். இந்த அணுகுமுறை பல நன்மைகளை வழங்குகிறது, ஆனால் இது சுழற்சி தரவு கட்டமைப்புகளுடன் (cyclic data structures) குறிப்பாக சவால்களை எதிர்கொள்கிறது. இந்தக் கட்டுரை குறிப்பு எண்ணுதல், அதன் நன்மைகள், வரம்புகள் மற்றும் சுழற்சி குப்பை சேகரிப்பைச் செயல்படுத்துவதற்கான உத்திகள் பற்றிய விரிவான கண்ணோட்டத்தை வழங்குகிறது.

குறிப்பு எண்ணுதல் என்றால் என்ன?

குறிப்பு எண்ணுதல் என்பது ஒரு தானியங்கி நினைவக மேலாண்மை வடிவமாகும். பயன்படுத்தப்படாத பொருட்களைக் கண்டறிய ஒரு குப்பை சேகரிப்பான் (garbage collector) அவ்வப்போது நினைவகத்தை ஸ்கேன் செய்வதற்குப் பதிலாக, குறிப்பு எண்ணுதல் ஒரு பொருள் அணுக முடியாததாக மாறியவுடன் நினைவகத்தை மீட்டெடுக்க நோக்கமாகக் கொண்டுள்ளது. நினைவகத்தில் உள்ள ஒவ்வொரு பொருளுக்கும் அதனுடன் தொடர்புடைய குறிப்பு எண்ணிக்கை உள்ளது, இது அந்தப் பொருளுக்கான குறிப்புகளின் (சுட்டிகள், இணைப்புகள் போன்றவை) எண்ணிக்கையைக் குறிக்கிறது. அதன் அடிப்படை செயல்பாடுகள்:

• குறிப்பு எண்ணிக்கையை அதிகரித்தல்: ஒரு பொருளுக்கு ஒரு புதிய குறிப்பு உருவாக்கப்படும்போது, அந்தப் பொருளின் குறிப்பு எண்ணிக்கை அதிகரிக்கப்படுகிறது.
• குறிப்பு எண்ணிக்கையைக் குறைத்தல்: ஒரு பொருளுக்கான குறிப்பு அகற்றப்படும்போது அல்லது அதன் வரம்பை விட்டு வெளியேறும்போது, அந்தப் பொருளின் குறிப்பு எண்ணிக்கை குறைக்கப்படுகிறது.
• நீக்குதல்: ஒரு பொருளின் குறிப்பு எண்ணிக்கை பூஜ்ஜியத்தை அடையும்போது, அந்தப் பொருள் நிரலின் வேறு எந்தப் பகுதியாலும் குறிப்பிடப்படவில்லை என்று அர்த்தம். இந்த நேரத்தில், அந்தப் பொருளை நீக்கி அதன் நினைவகத்தை மீட்டெடுக்க முடியும்.

எடுத்துக்காட்டு: பைத்தானில் ஒரு எளிய சூழ்நிலையைக் கவனியுங்கள் (பைத்தான் முதன்மையாக ஒரு ட்ரேசிங் குப்பை சேகரிப்பானைப் பயன்படுத்தினாலும், உடனடி சுத்திகரிப்புக்கு குறிப்பு எண்ணுதலையும் பயன்படுத்துகிறது):

obj1 = MyObject()
obj2 = obj1  # Increment reference count of obj1
del obj1  # Decrement reference count of MyObject; object is still accessible through obj2
del obj2  # Decrement reference count of MyObject; if this was the last reference, the object is deallocated

குறிப்பு எண்ணுதலின் நன்மைகள்

குறிப்பு எண்ணுதல் மற்ற நினைவக மேலாண்மை நுட்பங்களான ட்ரேசிங் குப்பை சேகரிப்பு போன்றவற்றை விட பல கட்டாய நன்மைகளை வழங்குகிறது:

• உடனடி மீட்பு: ஒரு பொருள் அணுக முடியாததாக மாறியவுடன் நினைவகம் மீட்டெடுக்கப்படுகிறது, இது நினைவகப் பயன்பாட்டைக் குறைத்து, பாரம்பரிய குப்பை சேகரிப்பான்களுடன் தொடர்புடைய நீண்ட இடைநிறுத்தங்களைத் தவிர்க்கிறது. இந்த தீர்மானகரமான நடத்தை நிகழ்நேர அமைப்புகள் அல்லது கடுமையான செயல்திறன் தேவைகளைக் கொண்ட பயன்பாடுகளில் குறிப்பாக பயனுள்ளதாக இருக்கும்.
• எளிமை: அடிப்படை குறிப்பு எண்ணுதல் நெறிமுறையைச் செயல்படுத்துவது ஒப்பீட்டளவில் நேரடியானது, இது உட்பொதிக்கப்பட்ட அமைப்புகள் அல்லது வரையறுக்கப்பட்ட வளங்களைக் கொண்ட சூழல்களுக்கு ஏற்றதாக அமைகிறது.
• குறிப்பு இருப்பிடம்: ஒரு பொருளை நீக்குவது பெரும்பாலும் அது குறிப்பிடும் பிற பொருட்களை நீக்குவதற்கு வழிவகுக்கிறது, இது கேச் செயல்திறனை மேம்படுத்துகிறது மற்றும் நினைவக துண்டாக்கலைக் குறைக்கிறது.

குறிப்பு எண்ணுதலின் வரம்புகள்

அதன் நன்மைகள் இருந்தபோதிலும், குறிப்பு எண்ணுதல் பல வரம்புகளால் பாதிக்கப்படுகிறது, இது சில சூழ்நிலைகளில் அதன் நடைமுறைத்தன்மையை பாதிக்கலாம்:

• கூடுதல் சுமை: குறிப்பு எண்ணிக்கையை அதிகரிப்பதும் குறைப்பதும் குறிப்பிடத்தக்க கூடுதல் சுமையை அறிமுகப்படுத்தலாம், குறிப்பாக அடிக்கடி பொருள் உருவாக்கம் மற்றும் நீக்கம் உள்ள அமைப்புகளில். இந்த கூடுதல் சுமை பயன்பாட்டின் செயல்திறனைப் பாதிக்கலாம்.
• வட்டக் குறிப்புகள்: அடிப்படை குறிப்பு எண்ணுதலின் மிக முக்கியமான வரம்பு வட்டக் குறிப்புகளைக் கையாள இயலாமை ஆகும். இரண்டு அல்லது அதற்கு மேற்பட்ட பொருட்கள் ஒன்றையொன்று குறிப்பிடும்போது, நிரலின் மற்ற பகுதிகளிலிருந்து அவை அணுக முடியாததாக இருந்தாலும், அவற்றின் குறிப்பு எண்ணிக்கை ஒருபோதும் பூஜ்ஜியத்தை அடையாது. இது நினைவக கசிவுகளுக்கு (memory leaks) வழிவகுக்கிறது.
• சிக்கலானது: குறிப்பு எண்ணுதலை சரியாகச் செயல்படுத்துவதற்கு, குறிப்பாக பன்முனை சூழல்களில் (multithreaded environments), போட்டி நிலைகளைத் (race conditions) தவிர்க்கவும், துல்லியமான குறிப்பு எண்ணிக்கையை உறுதி செய்யவும் கவனமான ஒத்திசைவு தேவைப்படுகிறது. இது செயலாக்கத்தில் சிக்கலைச் சேர்க்கலாம்.

வட்டக் குறிப்பு சிக்கல்

வட்டக் குறிப்பு சிக்கல் என்பது அனுபவமற்ற குறிப்பு எண்ணுதலின் மிகப்பெரிய பலவீனமாகும். A மற்றும் B என்ற இரண்டு பொருட்களைக் கவனியுங்கள், இதில் A, B-ஐயும், B, A-வையும் குறிப்பிடுகிறது. வேறு எந்தப் பொருளும் A அல்லது B-ஐக் குறிப்பிடவில்லை என்றாலும், அவற்றின் குறிப்பு எண்ணிக்கை குறைந்தபட்சம் ஒன்றாக இருக்கும், இது அவற்றை நீக்குவதைத் தடுக்கிறது. இது ஒரு நினைவகக் கசிவை உருவாக்குகிறது, ஏனெனில் A மற்றும் B ஆல் ஆக்கிரமிக்கப்பட்ட நினைவகம் ஒதுக்கப்பட்டதாக ஆனால் அணுக முடியாததாகவே உள்ளது.

எடுத்துக்காட்டு: பைத்தானில்:

class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

node1 = Node(1)
node2 = Node(2)

node1.next = node2
node2.next = node1  # Circular reference created

del node1
del node2  # Memory leak: the nodes are no longer accessible, but their reference counts are still 1

C++ போன்ற மொழிகளில் ஸ்மார்ட் பாயிண்டர்களை (`std::shared_ptr` போன்றவை) பயன்படுத்தும்போது, கவனமாகக் கையாளப்படாவிட்டால் இந்த நடத்தை ஏற்படலாம். `shared_ptr`-களின் சுழற்சிகள் நீக்கப்படுவதைத் தடுக்கும்.

சுழற்சி குப்பை சேகரிப்பு உத்திகள்

வட்டக் குறிப்பு சிக்கலைத் தீர்க்க, குறிப்பு எண்ணுதலுடன் இணைந்து பல சுழற்சி குப்பை சேகரிப்பு நுட்பங்களைப் பயன்படுத்தலாம். இந்த நுட்பங்கள் அணுக முடியாத பொருட்களின் சுழற்சிகளைக் கண்டறிந்து உடைப்பதை நோக்கமாகக் கொண்டுள்ளன, இதனால் அவற்றை நீக்க அனுமதிக்கிறது.

1. மார்க் மற்றும் ஸ்வீப் நெறிமுறை

மார்க் மற்றும் ஸ்வீப் நெறிமுறை (Mark and Sweep algorithm) என்பது பரவலாகப் பயன்படுத்தப்படும் ஒரு குப்பை சேகரிப்பு நுட்பமாகும், இது குறிப்பு எண்ணுதல் அமைப்புகளில் சுழற்சி குறிப்புகளைக் கையாளப் பயன்படுத்தப்படலாம். இது இரண்டு கட்டங்களை உள்ளடக்கியது:

• மார்க் கட்டம்: ரூட் பொருட்களின் (நிரலிலிருந்து நேரடியாக அணுகக்கூடிய பொருட்கள்) தொகுப்பிலிருந்து தொடங்கி, இந்த நெறிமுறை பொருள் வரைபடத்தை (object graph) கடந்து, அணுகக்கூடிய அனைத்து பொருட்களையும் குறிக்கிறது.
• ஸ்வீப் கட்டம்: மார்க் கட்டத்திற்குப் பிறகு, நெறிமுறை முழு நினைவக இடத்தையும் ஸ்கேன் செய்து, குறிக்கப்படாத பொருட்களை அடையாளம் காண்கிறது. இந்த குறிக்கப்படாத பொருட்கள் அணுக முடியாததாகக் கருதப்பட்டு நீக்கப்படுகின்றன.

குறிப்பு எண்ணுதல் சூழலில், அணுக முடியாத பொருட்களின் சுழற்சிகளைக் கண்டறிய மார்க் மற்றும் ஸ்வீப் நெறிமுறையைப் பயன்படுத்தலாம். இந்த நெறிமுறை தற்காலிகமாக அனைத்து பொருட்களின் குறிப்பு எண்ணிக்கையையும் பூஜ்ஜியமாக அமைத்து, பின்னர் மார்க் கட்டத்தைச் செய்கிறது. மார்க் கட்டத்திற்குப் பிறகு ஒரு பொருளின் குறிப்பு எண்ணிக்கை பூஜ்ஜியமாக இருந்தால், அந்தப் பொருள் எந்த ரூட் பொருட்களிலிருந்தும் அணுகப்படவில்லை மற்றும் அது ஒரு அணுக முடியாத சுழற்சியின் ஒரு பகுதியாகும் என்று அர்த்தம்.

செயல்படுத்தல் பரிசீலனைகள்:

• மார்க் மற்றும் ஸ்வீப் நெறிமுறை அவ்வப்போது அல்லது நினைவகப் பயன்பாடு ஒரு குறிப்பிட்ட வரம்பை அடையும்போது தூண்டப்படலாம்.
• முடிவற்ற சுழற்சிகளைத் தவிர்க்க, மார்க் கட்டத்தின் போது வட்டக் குறிப்புகளைக் கவனமாகக் கையாள்வது முக்கியம்.
• இந்த நெறிமுறை பயன்பாட்டுச் செயல்பாட்டில், குறிப்பாக ஸ்வீப் கட்டத்தின் போது, இடைநிறுத்தங்களை அறிமுகப்படுத்தலாம்.

2. சுழற்சி கண்டறிதல் நெறிமுறைகள்

பொருள் வரைபடங்களில் சுழற்சிகளைக் கண்டறிவதற்காகப் பல சிறப்பு நெறிமுறைகள் வடிவமைக்கப்பட்டுள்ளன. இந்த நெறிமுறைகள் குறிப்பு எண்ணுதல் அமைப்புகளில் அணுக முடியாத பொருட்களின் சுழற்சிகளைக் கண்டறியப் பயன்படுத்தப்படலாம்.

அ) டார்ஜனின் வலுவாக இணைக்கப்பட்ட கூறுகள் நெறிமுறை

டார்ஜனின் நெறிமுறை (Tarjan's algorithm) என்பது ஒரு இயக்கப்பட்ட வரைபடத்தில் (directed graph) வலுவாக இணைக்கப்பட்ட கூறுகளை (Strongly Connected Components - SCCs) அடையாளம் காணும் ஒரு வரைபடப் பயண நெறிமுறையாகும். ஒரு SCC என்பது ஒவ்வொரு முனையும் மற்ற எல்லா முனைகளிலிருந்தும் அணுகக்கூடிய ஒரு துணை வரைபடம் ஆகும். குப்பை சேகரிப்பு சூழலில், SCC-கள் பொருட்களின் சுழற்சிகளைக் குறிக்கலாம்.

இது எப்படி வேலை செய்கிறது:

• இந்த நெறிமுறை பொருள் வரைபடத்தின் ஆழம்-முதல் தேடலை (depth-first search - DFS) செய்கிறது.
• DFS-ன் போது, ஒவ்வொரு பொருளுக்கும் ஒரு தனித்துவமான குறியீட்டு எண் மற்றும் ஒரு லோ-லிங்க் (lowlink) மதிப்பு ஒதுக்கப்படும்.
• லோ-லிங்க் மதிப்பு தற்போதைய பொருளிலிருந்து அடையக்கூடிய எந்தவொரு பொருளின் மிகச்சிறிய குறியீட்டு எண்ணைக் குறிக்கிறது.
• DFS ஏற்கனவே அடுக்கில் (stack) உள்ள ஒரு பொருளை சந்திக்கும்போது, அது தற்போதைய பொருளின் லோ-லிங்க் மதிப்பை புதுப்பிக்கிறது.
• DFS ஒரு SCC-ஐ செயலாக்கி முடித்தவுடன், அது SCC-இல் உள்ள அனைத்து பொருட்களையும் அடுக்கிலிருந்து அகற்றி, அவற்றை ஒரு சுழற்சியின் பகுதியாக அடையாளம் காண்கிறது.

ஆ) பாதை அடிப்படையிலான வலுவான கூறு நெறிமுறை

பாதை அடிப்படையிலான வலுவான கூறு நெறிமுறை (Path-Based Strong Component algorithm - PBSCA) என்பது ஒரு இயக்கப்பட்ட வரைபடத்தில் SCC-களை அடையாளம் காண்பதற்கான மற்றொரு நெறிமுறையாகும். இது பொதுவாக டார்ஜனின் நெறிமுறையை விட நடைமுறையில், குறிப்பாக அடர்த்தியற்ற வரைபடங்களுக்கு, திறமையானது.

இது எப்படி வேலை செய்கிறது:

• இந்த நெறிமுறை DFS-ன் போது பார்வையிடப்பட்ட பொருட்களின் அடுக்கை பராமரிக்கிறது.
• ஒவ்வொரு பொருளுக்கும், அது ரூட் பொருளிலிருந்து தற்போதைய பொருளுக்கு வழிவகுக்கும் பாதையைச் சேமிக்கிறது.
• நெறிமுறை ஏற்கனவே அடுக்கில் உள்ள ஒரு பொருளை சந்திக்கும்போது, அது தற்போதைய பொருளுக்கான பாதையை அடுக்கில் உள்ள பொருளுக்கான பாதையுடன் ஒப்பிடுகிறது.
• தற்போதைய பொருளுக்கான பாதை, அடுக்கில் உள்ள பொருளுக்கான பாதையின் முன்னொட்டாக இருந்தால், தற்போதைய பொருள் ஒரு சுழற்சியின் ஒரு பகுதியாகும் என்று அர்த்தம்.

3. ஒத்திவைக்கப்பட்ட குறிப்பு எண்ணுதல்

ஒத்திவைக்கப்பட்ட குறிப்பு எண்ணுதல் (Deferred reference counting) என்பது குறிப்பு எண்ணிக்கையை அதிகரிப்பதும் குறைப்பதுமான செயல்பாடுகளைப் பிற்காலத்திற்கு ஒத்திவைப்பதன் மூலம் கூடுதல் சுமையைக் குறைப்பதை நோக்கமாகக் கொண்டுள்ளது. குறிப்பு எண்ணிக்கை மாற்றங்களை பஃபரிங் செய்து அவற்றை தொகுப்புகளாகப் பயன்படுத்துவதன் மூலம் இதை அடைய முடியும்.

நுட்பங்கள்:

• திரெட்-லோக்கல் பஃபர்கள்: ஒவ்வொரு திரெட்டும் குறிப்பு எண்ணிக்கை மாற்றங்களைச் சேமிக்க ஒரு உள்ளூர் பஃபரை பராமரிக்கிறது. இந்த மாற்றங்கள் உலகளாவிய குறிப்பு எண்ணிக்கையில் அவ்வப்போது அல்லது பஃபர் நிரம்பும்போது பயன்படுத்தப்படுகின்றன.
• ரைட் பேரியர்கள்: பொருள் புலங்களுக்கான எழுதுதல்களை இடைமறிக்க ரைட் பேரியர்கள் (Write barriers) பயன்படுத்தப்படுகின்றன. ஒரு எழுதுதல் செயல்பாடு ஒரு புதிய குறிப்பை உருவாக்கும்போது, ரைட் பேரியர் அந்த எழுதுதலை இடைமறித்து, குறிப்பு எண்ணிக்கை அதிகரிப்பை ஒத்திவைக்கிறது.

ஒத்திவைக்கப்பட்ட குறிப்பு எண்ணுதல் கூடுதல் சுமையைக் குறைக்க முடியும் என்றாலும், இது நினைவகத்தை மீட்டெடுப்பதை தாமதப்படுத்தலாம், இதனால் நினைவகப் பயன்பாட்டை அதிகரிக்கக்கூடும்.

4. பகுதி மார்க் மற்றும் ஸ்வீப்

முழு நினைவக இடத்திலும் ஒரு முழுமையான மார்க் மற்றும் ஸ்வீப் செய்வதற்குப் பதிலாக, ஒரு குறிப்பிட்ட பொருள் அல்லது பொருட்களின் குழுவிலிருந்து அணுகக்கூடிய பொருட்கள் போன்ற நினைவகத்தின் ஒரு சிறிய பகுதியில் ஒரு பகுதி மார்க் மற்றும் ஸ்வீப் (Partial Mark and Sweep) செய்யப்படலாம். இது குப்பை சேகரிப்புடன் தொடர்புடைய இடைநிறுத்த நேரங்களைக் குறைக்கலாம்.

செயல்படுத்தல்:

• இந்த நெறிமுறை சந்தேகத்திற்குரிய பொருட்களின் (ஒரு சுழற்சியின் பகுதியாக இருக்க வாய்ப்புள்ள பொருட்கள்) தொகுப்பிலிருந்து தொடங்குகிறது.
• இது இந்தப் பொருட்களிலிருந்து அணுகக்கூடிய பொருள் வரைபடத்தைக் கடந்து, அணுகக்கூடிய அனைத்து பொருட்களையும் குறிக்கிறது.
• பின்னர் அது குறிக்கப்பட்ட பகுதியை ஸ்வீப் செய்து, குறிக்கப்படாத எந்தப் பொருட்களையும் நீக்குகிறது.

பல்வேறு மொழிகளில் சுழற்சி குப்பை சேகரிப்பை செயல்படுத்துதல்

சுழற்சி குப்பை சேகரிப்பின் செயலாக்கம் நிரலாக்க மொழி மற்றும் அதன் அடிப்படையிலான நினைவக மேலாண்மை அமைப்பைப் பொறுத்து மாறுபடலாம். இதோ சில எடுத்துக்காட்டுகள்:

பைத்தான்

பைத்தான் நினைவகத்தை நிர்வகிக்க குறிப்பு எண்ணுதல் மற்றும் ஒரு ட்ரேசிங் குப்பை சேகரிப்பான் ஆகியவற்றின் கலவையைப் பயன்படுத்துகிறது. குறிப்பு எண்ணுதல் கூறு பொருட்களின் உடனடி நீக்கத்தைக் கையாளுகிறது, அதே நேரத்தில் ட்ரேசிங் குப்பை சேகரிப்பான் அணுக முடியாத பொருட்களின் சுழற்சிகளைக் கண்டறிந்து உடைக்கிறது.

பைத்தானில் குப்பை சேகரிப்பான் `gc` மாட்யூலில் செயல்படுத்தப்பட்டுள்ளது. நீங்கள் `gc.collect()` செயல்பாட்டைப் பயன்படுத்தி குப்பை சேகரிப்பை கைமுறையாகத் தூண்டலாம். குப்பை சேகரிப்பான் குறிப்பிட்ட இடைவெளிகளில் தானாகவும் இயங்கும்.

எடுத்துக்காட்டு:

import gc

class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

node1 = Node(1)
node2 = Node(2)

node1.next = node2
node2.next = node1  # Circular reference created

del node1
del node2

gc.collect()  # Force garbage collection to break the cycle

சி++

சி++ல் உள்ளமைக்கப்பட்ட குப்பை சேகரிப்பு இல்லை. நினைவக மேலாண்மை பொதுவாக `new` மற்றும் `delete` அல்லது ஸ்மார்ட் பாயிண்டர்களைப் பயன்படுத்தி கைமுறையாகக் கையாளப்படுகிறது.

சி++ல் சுழற்சி குப்பை சேகரிப்பைச் செயல்படுத்த, நீங்கள் சுழற்சி கண்டறிதலுடன் கூடிய ஸ்மார்ட் பாயிண்டர்களைப் பயன்படுத்தலாம். ஒரு அணுகுமுறை `std::weak_ptr` ஐப் பயன்படுத்தி சுழற்சிகளை உடைப்பதாகும். ஒரு `weak_ptr` என்பது அது சுட்டிக்காட்டும் பொருளின் குறிப்பு எண்ணிக்கையை அதிகரிக்காத ஒரு ஸ்மார்ட் பாயிண்டர் ஆகும். இது பொருட்களை நீக்குவதைத் தடுக்காமல் பொருட்களின் சுழற்சிகளை உருவாக்க உங்களை அனுமதிக்கிறது.

எடுத்துக்காட்டு:

#include 
#include 

class Node {
public:
    int data;
    std::shared_ptr next;
    std::weak_ptr prev;  // Use weak_ptr to break cycles

    Node(int data) : data(data) {}
    ~Node() { std::cout << "Node destroyed with data: " << data << std::endl; }
};

int main() {
    std::shared_ptr node1 = std::make_shared(1);
    std::shared_ptr node2 = std::make_shared(2);

    node1->next = node2;
    node2->prev = node1; // Cycle created, but prev is weak_ptr

    node2.reset();
    node1.reset(); // Nodes will now be destroyed

    return 0;
}

இந்த எடுத்துக்காட்டில், `node2` `node1`-க்கு ஒரு `weak_ptr`-ஐக் கொண்டுள்ளது. `node1` மற்றும் `node2` இரண்டும் அவற்றின் வரம்பை விட்டு வெளியேறும்போது, அவற்றின் பகிரப்பட்ட பாயிண்டர்கள் அழிக்கப்படுகின்றன, மேலும் வீக் பாயிண்டர் குறிப்பு எண்ணிக்கைக்கு பங்களிக்காததால் பொருட்கள் நீக்கப்படுகின்றன.

ஜாவா

ஜாவா ஒரு தானியங்கி குப்பை சேகரிப்பானைப் பயன்படுத்துகிறது, இது ட்ரேசிங் மற்றும் சில வகையான குறிப்பு எண்ணுதலை உள்நாட்டில் கையாளுகிறது. வட்டக் குறிப்புகளில் ஈடுபட்டுள்ளவை உட்பட, அணுக முடியாத பொருட்களைக் கண்டறிந்து மீட்டெடுப்பதற்கு குப்பை சேகரிப்பான் பொறுப்பாகும். நீங்கள் பொதுவாக ஜாவாவில் சுழற்சி குப்பை சேகரிப்பை வெளிப்படையாகச் செயல்படுத்தத் தேவையில்லை.

இருப்பினும், குப்பை சேகரிப்பான் எவ்வாறு செயல்படுகிறது என்பதைப் புரிந்துகொள்வது மேலும் திறமையான குறியீட்டை எழுத உதவும். குப்பை சேகரிப்புச் செயல்பாட்டைக் கண்காணிக்கவும், சாத்தியமான நினைவகக் கசிவுகளை அடையாளம் காணவும் ப்ரொஃபைலர்கள் போன்ற கருவிகளைப் பயன்படுத்தலாம்.

ஜாவாஸ்கிரிப்ட்

ஜாவாஸ்கிரிப்ட் நினைவகத்தை நிர்வகிக்க குப்பை சேகரிப்பை (பெரும்பாலும் ஒரு மார்க்-அண்ட்-ஸ்வீப் நெறிமுறை) நம்பியுள்ளது. குறிப்பு எண்ணுதல் என்பது எஞ்சின் பொருட்களைக் கண்காணிக்கும் ஒரு பகுதியாக இருந்தாலும், டெவலப்பர்கள் குப்பை சேகரிப்பை நேரடியாகக் கட்டுப்படுத்துவதில்லை. சுழற்சிகளைக் கண்டறிவதற்கு எஞ்சினே பொறுப்பாகும்.

இருப்பினும், தற்செயலாக பெரிய பொருள் வரைபடங்களை உருவாக்குவதைக் கவனத்தில் கொள்ள வேண்டும், இது குப்பை சேகரிப்பு சுழற்சிகளை மெதுவாக்கக்கூடும். பொருட்கள் இனி தேவைப்படாதபோது அவற்றிற்கான குறிப்புகளை உடைப்பது, நினைவகத்தை மிகவும் திறமையாக மீட்டெடுக்க எஞ்சினுக்கு உதவுகிறது.

குறிப்பு எண்ணுதல் மற்றும் சுழற்சி குப்பை சேகரிப்புக்கான சிறந்த நடைமுறைகள்

• வட்டக் குறிப்புகளைக் குறைத்தல்: வட்டக் குறிப்புகளின் உருவாக்கத்தைக் குறைக்க உங்கள் தரவுக் கட்டமைப்புகளை வடிவமைக்கவும். சுழற்சிகளை முற்றிலுமாகத் தவிர்க்க மாற்றுத் தரவுக் கட்டமைப்புகள் அல்லது நுட்பங்களைப் பயன்படுத்துவதைக் கருத்தில் கொள்ளுங்கள்.
• வீக் குறிப்புகளைப் பயன்படுத்தவும்: வீக் குறிப்புகளை ஆதரிக்கும் மொழிகளில், சுழற்சிகளை உடைக்க அவற்றைப் பயன்படுத்தவும். வீக் குறிப்புகள் அவை சுட்டிக்காட்டும் பொருளின் குறிப்பு எண்ணிக்கையை அதிகரிக்காது, இதனால் அந்தப் பொருள் ஒரு சுழற்சியின் பகுதியாக இருந்தாலும் அதை நீக்க அனுமதிக்கிறது.
• சுழற்சி கண்டறிதலைச் செயல்படுத்தவும்: உள்ளமைக்கப்பட்ட சுழற்சி கண்டறிதல் இல்லாத ஒரு மொழியில் நீங்கள் குறிப்பு எண்ணுதலைப் பயன்படுத்தினால், அணுக முடியாத பொருட்களின் சுழற்சிகளைக் கண்டறிந்து உடைக்க ஒரு சுழற்சி கண்டறிதல் நெறிமுறையைச் செயல்படுத்தவும்.
• நினைவகப் பயன்பாட்டைக் கண்காணிக்கவும்: சாத்தியமான நினைவகக் கசிவுகளைக் கண்டறிய நினைவகப் பயன்பாட்டைக் கண்காணிக்கவும். சரியாக நீக்கப்படாத பொருட்களை அடையாளம் காண ப்ரொஃபைலிங் கருவிகளைப் பயன்படுத்தவும்.
• குறிப்பு எண்ணுதல் செயல்பாடுகளை மேம்படுத்தவும்: கூடுதல் சுமையைக் குறைக்க குறிப்பு எண்ணுதல் செயல்பாடுகளை மேம்படுத்தவும். செயல்திறனை மேம்படுத்த ஒத்திவைக்கப்பட்ட குறிப்பு எண்ணுதல் அல்லது ரைட் பேரியர்கள் போன்ற நுட்பங்களைப் பயன்படுத்துவதைக் கருத்தில் கொள்ளுங்கள்.
• சாதக பாதகங்களைக் கருத்தில் கொள்ளுங்கள்: குறிப்பு எண்ணுதல் மற்றும் பிற நினைவக மேலாண்மை நுட்பங்களுக்கு இடையிலான சாதக பாதகங்களை மதிப்பீடு செய்யுங்கள். எல்லா பயன்பாடுகளுக்கும் குறிப்பு எண்ணுதல் சிறந்த தேர்வாக இருக்காது. உங்கள் முடிவை எடுக்கும்போது குறிப்பு எண்ணுதலின் சிக்கலான தன்மை, கூடுதல் சுமை மற்றும் வரம்புகளைக் கருத்தில் கொள்ளுங்கள்.

முடிவுரை

குறிப்பு எண்ணுதல் என்பது உடனடி மீட்பு மற்றும் எளிமையை வழங்கும் ஒரு மதிப்புமிக்க நினைவக மேலாண்மை நுட்பமாகும். இருப்பினும், வட்டக் குறிப்புகளைக் கையாள இயலாமை ஒரு குறிப்பிடத்தக்க வரம்பாகும். மார்க் மற்றும் ஸ்வீப் அல்லது சுழற்சி கண்டறிதல் நெறிமுறைகள் போன்ற சுழற்சி குப்பை சேகரிப்பு நுட்பங்களைச் செயல்படுத்துவதன் மூலம், இந்த வரம்பை நீங்கள் கடந்து, நினைவகக் கசிவுகளின் ஆபத்து இல்லாமல் குறிப்பு எண்ணுதலின் நன்மைகளைப் பெறலாம். குறிப்பு எண்ணுதலுடன் தொடர்புடைய சாதக பாதகங்கள் மற்றும் சிறந்த நடைமுறைகளைப் புரிந்துகொள்வது, வலுவான மற்றும் திறமையான மென்பொருள் அமைப்புகளை உருவாக்குவதற்கு முக்கியமானது. உங்கள் பயன்பாட்டின் குறிப்பிட்ட தேவைகளைக் கவனமாகக் கருத்தில் கொண்டு, உங்கள் தேவைகளுக்கு மிகவும் பொருத்தமான நினைவக மேலாண்மை உத்தியைத் தேர்வுசெய்து, வட்டக் குறிப்புகளின் சவால்களைத் தணிக்கத் தேவையான இடங்களில் சுழற்சி குப்பை சேகரிப்பை இணைக்கவும். திறமையான நினைவகப் பயன்பாட்டை உறுதிப்படுத்தவும், சாத்தியமான நினைவகக் கசிவுகளைத் தடுக்கவும் உங்கள் குறியீட்டை ப்ரொஃபைல் செய்து மேம்படுத்த நினைவில் கொள்ளுங்கள்.